import request from "@/utils/request.js"
/**
 * 获取水平衡图数据
 * @param {Object} params 请求参数
 * @param {string} params.start_time - 开始时间
 * @param {string} params.end_time - 结束时间
 * @param {string} params.id - 公司id
 * @returns {Promise<WaterBalanceResponse>} 水平衡数据
 */
export function getWaterBalanceApi(params) {
    return request.get('/algorithm/water_balance', {
        params: params
    })
}
import dayjs from 'dayjs';

/**
 * 获取指定时间戳范围的所有月份范围
 * @param {number} startTimestamp - 开始时间13位时间戳
 * @param {number} endTimestamp - 结束时间13位时间戳
 * @returns {Array} 月份范围数组
 */
const getMonthRanges = (startTimestamp, endTimestamp) => {
    const ranges = [];
    const start = dayjs(startTimestamp);
    const end = dayjs(endTimestamp);

    let current = start.startOf('month');

    while (current.isSameOrBefore(end)) {
        const monthStart = current;
        const monthEnd = current.endOf('month');

        // 确保不超出指定的结束时间
        const actualEnd = monthEnd.isAfter(end) ? end : monthEnd;
        // 确保不早于指定的开始时间
        const actualStart = monthStart.isBefore(start) ? start : monthStart;

        ranges.push({
            start: actualStart.valueOf(), // 13位时间戳
            end: actualEnd.valueOf()      // 13位时间戳
        });

        current = current.add(1, 'month');
    }

    return ranges;
};

/**
 * 按月聚合不明水数据
 * @param {Array} dailyData - 日不明水数据数组
 * @returns {Array} 按月聚合后的数据
 */
const aggregateUnknownWaterByMonth = (dailyData) => {
    if (!Array.isArray(dailyData) || dailyData.length === 0) {
        return [];
    }

    // 按月分组数据
    const monthlyGroups = {};

    dailyData.forEach(item => {
        // 处理时间戳或ISO字符串
        let timestamp;
        if (typeof item.start_time === 'string') {
            timestamp = dayjs(item.start_time).valueOf();
        } else {
            timestamp = parseInt(item.start_time);
        }

        const date = dayjs(timestamp);
        const monthKey = date.format('YYYY-MM');

        if (!monthlyGroups[monthKey]) {
            monthlyGroups[monthKey] = [];
        }
        monthlyGroups[monthKey].push(item);
    });

    // 聚合每月数据
    const monthlyData = Object.keys(monthlyGroups).map(monthKey => {
        const monthData = monthlyGroups[monthKey];

        // 按时间排序确保正确的开始和结束值
        monthData.sort((a, b) => {
            const timeA = typeof a.start_time === 'string'
                ? dayjs(a.start_time).valueOf()
                : parseInt(a.start_time);
            const timeB = typeof b.start_time === 'string'
                ? dayjs(b.start_time).valueOf()
                : parseInt(b.start_time);
            return timeA - timeB;
        });

        // 计算当月所有数据的总和
        const totals = monthData.reduce((sum, day) => {
            const data = day.data || {};
            return {
                top_usage: sum.top_usage + parseFloat(data.top_usage || 0),
                next_usage: sum.next_usage + parseFloat(data.next_usage || 0),
                unknown_water: sum.unknown_water + parseFloat(data.unknown_water || 0)
            };
        }, {
            top_usage: 0,
            next_usage: 0,
            unknown_water: 0
        });

        // 构建月统计数据 - 使用13位时间戳
        const monthDate = dayjs(monthKey + '-01');
        const startTime = monthDate.startOf('month').valueOf(); // 月初时间戳
        const endTime = monthDate.add(1, 'month').startOf('month').valueOf(); // 下个月第一天时间戳

        return {
            start_time: startTime,
            end_time: endTime,
            data: {
                top_usage: totals.top_usage.toFixed(2),
                next_usage: totals.next_usage.toFixed(2),
                unknown_water: totals.unknown_water.toFixed(2),
                errors: ""
            }
        };
    });

    // 按时间排序
    return monthlyData.sort((a, b) => a.start_time - b.start_time);
};

/**
 * 排序不明水时间序列数据
 * @param {Object} response - API响应数据
 * @returns {Object} 排序后的响应数据
 */
const sortUnknownWaterData = (response) => {
    if (response && response.data && Array.isArray(response.data)) {
        response.data.sort((a, b) => {
            const timeA = typeof a.start_time === 'string'
                ? dayjs(a.start_time).valueOf()
                : parseInt(a.start_time);
            const timeB = typeof b.start_time === 'string'
                ? dayjs(b.start_time).valueOf()
                : parseInt(b.start_time);
            return timeA - timeB;
        });
    }
    return response;
};

/**
 * 按月分批请求不明水数据并聚合
 * @param {Object} params - 请求参数
 * @returns {Promise} 聚合后的月统计数据
 */
const getMonthlyUnknownWaterData = async (params) => {
    try {
        const { start_time, end_time } = params;

        if (!start_time || !end_time) {
            throw new Error('按月聚合需要提供 start_time 和 end_time 参数（13位时间戳）');
        }

        // 确保时间戳为数字类型
        const startTimestamp = parseInt(start_time);
        const endTimestamp = parseInt(end_time);

        console.log(`开始按月聚合不明水数据：${dayjs(startTimestamp).format('YYYY-MM-DD')} 到 ${dayjs(endTimestamp).format('YYYY-MM-DD')}`);

        // 获取所有月份范围
        const monthRanges = getMonthRanges(startTimestamp, endTimestamp);
        const allMonthlyData = [];

        console.log(`共需要处理 ${monthRanges.length} 个月份`);

        // 按月分批请求
        for (let i = 0; i < monthRanges.length; i++) {
            const range = monthRanges[i];
            const dailyParams = {
                ...params,
                interval: 'day',
                start_time: range.start,
                end_time: range.end
            };

            try {
                console.log(`正在请求第 ${i + 1}/${monthRanges.length} 个月的不明水数据：${dayjs(range.start).format('YYYY-MM-DD')} 到 ${dayjs(range.end).format('YYYY-MM-DD')}`);

                const response = await request.get('/algorithm/unknown_water', { params: dailyParams });

                if (response && response.data && response.data.length > 0) {
                    console.log(`获取到 ${response.data.length} 条日不明水数据`);

                    // 聚合当月数据
                    const monthlyData = aggregateUnknownWaterByMonth(response.data);
                    if (monthlyData.length > 0) {
                        allMonthlyData.push(...monthlyData);
                        console.log(`成功聚合为 ${monthlyData.length} 条月不明水数据`);
                    }
                } else {
                    console.log(`当月无不明水数据`);
                }
            } catch (error) {
                console.warn(`获取 ${dayjs(range.start).format('YYYY-MM-DD')} 到 ${dayjs(range.end).format('YYYY-MM-DD')} 的不明水数据失败:`, error);
                // 继续处理其他月份的数据
            }
        }

        console.log(`不明水月聚合完成，共生成 ${allMonthlyData.length} 条月统计数据`);

        return {
            message: "成功完成",
            code: 200,
            data: allMonthlyData.sort((a, b) => a.start_time - b.start_time)
        };

    } catch (error) {
        console.error('按月聚合不明水数据失败:', error);
        throw error;
    }
};

/**
 * 获取不明水数据的API
 * @description 获取指定时间范围内的不明水用量数据可以分片
 * @param {Object} [params={}] - 请求参数对象
 * @param {number} [params.id] - 公司id
 * @param {number} [params.start_time] - 开始时间13位时间戳
 * @param {number} [params.end_time] - 结束时间13位时间戳
 * @param {string} [params.interval] - 时间间隔 可选不选传所有数据
 * @param {boolean} [params.aggregateToMonth] - 是否聚合日数据为月数据（可选，仅当interval为month时有效）
 * @returns {Promise<Object>} 返回Promise对象
 * @returns {string} response.data.top_usage - 所有带二级表的一级表包括环网用水量
 * @returns {string} response.data.next_usage - 所有二级表用水量
 * @returns {string} response.data.unknown_water - 不明水用量
 * @returns {string} response.data.errors - 错误信息
 */
export const getUnknownWaterApi = async (params = {}) => {
    try {
        // 如果请求月统计且需要聚合日数据
        if (params.interval === 'month') {
            return await getMonthlyUnknownWaterData(params);
        }

        // 普通请求
        return request.get('/algorithm/unknown_water', { params })
            .then(sortUnknownWaterData);

    } catch (error) {
        console.error('获取不明水数据失败:', error);
        throw error;
    }
};

/**
 * 时间戳工具函数
 */
export const timeUtils = {
    // 将日期字符串转为13位时间戳
    dateToTimestamp: (dateStr) => dayjs(dateStr).valueOf(),

    // 将13位时间戳转为日期字符串
    timestampToDate: (timestamp, format = 'YYYY-MM-DD HH:mm:ss') => dayjs(timestamp).format(format),

    // 获取今天开始时间戳
    getTodayStart: () => dayjs().startOf('day').valueOf(),

    // 获取今天结束时间戳
    getTodayEnd: () => dayjs().endOf('day').valueOf(),

    // 获取本月开始时间戳
    getMonthStart: (timestamp = Date.now()) => dayjs(timestamp).startOf('month').valueOf(),

    // 获取本月结束时间戳
    getMonthEnd: (timestamp = Date.now()) => dayjs(timestamp).endOf('month').valueOf(),

    // 获取指定月份前N个月的时间戳
    getMonthsAgo: (months, timestamp = Date.now()) => dayjs(timestamp).subtract(months, 'month').valueOf()
};

/**
 * 计算不明水率的工具函数
 * @param {Object} data - 不明水数据
 * @param {string} data.top_usage - 一级表用量
 * @param {string} data.next_usage - 二级表用量
 * @param {string} data.unknown_water - 不明水用量
 * @returns {Object} 包含不明水率的对象
 */
export const calculateUnknownWaterRate = (data) => {
    const topUsage = parseFloat(data.top_usage || 0);
    const nextUsage = parseFloat(data.next_usage || 0);
    const unknownWater = parseFloat(data.unknown_water || 0);

    // 不明水率 = 不明水用量 / 一级表用量 * 100%
    const rate = topUsage > 0 ? (unknownWater / topUsage * 100) : 0;

    return {
        ...data,
        unknown_water_rate: rate.toFixed(2) + '%',
        total_usage: topUsage,
        accounted_usage: nextUsage,
        unaccounted_usage: unknownWater
    };
};
